package com.example.tool.activtiy;

import android.annotation.SuppressLint;
import android.content.ClipboardManager;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.TextView;

import com.example.tool.R;
import com.example.tool.activtiy.base.BaseActivity;
import com.example.tool.mvp.CommonPresent;
import com.example.tool.util.DebugLog;
import com.example.tool.util.ToastUtil;

import java.lang.ref.WeakReference;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import butterknife.BindView;

/**
 * 描述:多线程进阶优化
 *
 * @author: liangkun
 * @date: 2019/11/20 9:50
 */
public class ThreadActivity extends BaseActivity<CommonPresent> {
    @BindView(R.id.tv_pop_one)
    TextView textView;
    @BindView(R.id.tv_data)
    TextView tvData;
    @BindView(R.id.tv_title)
    protected TextView tvTitle;
    @BindView(R.id.tv_pop_2)
    protected TextView tvPop2;
    private String curThreadName;
    private ExecutorService executorService;

    /**
     * @param
     * @author liangkun
     * @description 优化的handler
     * @time 2019/11/20 14:56
     * @return
     */
    static class WeakHandler extends Handler {
        WeakReference<ThreadActivity> mActivity;

        WeakHandler(ThreadActivity activity) {
            mActivity = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            ThreadActivity theActivity = mActivity.get();
            if (theActivity == null || theActivity.isFinishing()) {
                return;
            }
            switch (msg.what) {

            }
        }
    }


    @Override
    protected int getLayoutId() {

        return R.layout.activtiy_thread;
    }

    @Override
    protected void initView() {
        tvTitle.setText("线程优化");
        textView.setText("开启线程");
        tvPop2.setText("Executors");
    }

    @Override
    protected void initData() {
        executorService = Executors.newFixedThreadPool(2);


    }

    @Override
    protected void initEvent() {
        textView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
//                CalculateSizeTask calculateSizeTask = new CalculateSizeTask(ThreadActivity.this);
//                calculateSizeTask.execute(DATA);
                boolean shutdown = executorService.isShutdown();
                DebugLog.d("-线程池是否存活2222  "+ shutdown);
                if(!executorService.isShutdown()){
                    executorService.shutdown();
                }
                DebugLog.d("-线程池是否存活1111  "+ executorService.isShutdown());
            }
        });
        tvPop2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if(!executorService.isShutdown()){
                    for (int i = 0; i <15; i++) {
                        int finalI = i;
                        executorService.execute(new Runnable() {
                            @Override
                            public void run() {
                                try {
                                    Thread.sleep(1000);
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                                DebugLog.d(Thread.currentThread().getName()+"-线程被调用了 i "+ finalI);
                            }
                        });
                    }
                }else {

                    ToastUtil.toastShortContent("线程池已经关闭.......");
                    executorService =Executors.newFixedThreadPool(2);
                }


            }
        });
    }

    @Override
    protected CommonPresent createPresenter() {
        return null;
    }

    //    AsyncTask

    /**
     * 主要涉及到的四个核心方法：
     * <p>
     * onPreExecute(): 在主线程处理一些准备工作。
     * <p>
     * doInBackground(Params…params): 在子线程中处理异步耗时任务，可以通过 publishProgress 方法来更新任务的进度。
     * <p>
     * onProgressUpdate(Progress…values): 在主线程中执行，当后台任务进度改变触发回调。
     * <p>
     * onPostExecute(Result result): 在主线程中，异步任务结束触发回调，其中 result 就是后台任务的返回值。
     */
    @SuppressLint("StaticFieldLeak")
    class CalculateSizeTask extends AsyncTask<String, Float, Long> {

        WeakReference<ThreadActivity> mActivity;

        CalculateSizeTask(ThreadActivity activity) {
            mActivity = new WeakReference<>(activity);
        }

        @Override
        protected Long doInBackground(String... urls) {
            ThreadActivity theActivity = mActivity.get();
            if (theActivity == null || theActivity.isFinishing()) {
                return 0L;
            }
            theActivity.curThreadName = Thread.currentThread().getName();
            int length = urls.length;
            long totalSize = 0;
            for (int i = 0; i < length; i++) {
                publishProgress(i * 1.0f / length);
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                totalSize += urls[i].length();
            }
            return totalSize;
        }

        @Override
        protected void onProgressUpdate(Float... values) {
            updateContent(String.format("%s%%", values[0]));
        }

        @Override
        protected void onPostExecute(Long aLong) {
            updateContent("Complete! totalSize:\t" + aLong);
        }

        @Override
        protected void onPreExecute() {
            updateContent("loading....");
        }

        @Override
        protected void onCancelled(Long aLong) {
            super.onCancelled(aLong);
            updateContent("已取消 " + aLong);
        }

        void updateContent(String content) {
            ThreadActivity theActivity = mActivity.get();
            if (theActivity == null || theActivity.isFinishing()) {
                return;
            }
            tvData.setText(curThreadName + "\n" + content);
        }
    }

//    ThreadPoolExecutor
//public ThreadPoolExecutor(int corePoolSize,
//                          int maximumPoolSize,
//                          long keepAliveTime,
//                          TimeUnit unit,
//                          BlockingQueue<Runnable> workQueue,
//                          ThreadFactory threadFactory)
    /**
     * corePoolSize: 线程池中核心的线程数。默认情况核心线程是一致存活，及时没有任何操作。但是如果执行了
     * allowCoreThreaTimeOut() 方法，核心线程也是有可能被回收的，这取决于是否处于闲置状态 & keepAliveTime 。
     *
     * maximumPollSize: 线程池所能容纳的最大线程数。超过限制，新线程会被阻塞。
     *
     * keepAliveTime: 线程闲置超时等待时间。超过此值会被回收。
     *
     * unit: 超时等待时间单位。
     *
     * workQueue: 线程池中的任务队列。每次执行 execute() 会把 runnable 对象存储在这个队列中。
     *
     * threadFactory: 线程工厂，为线程池提供创建新线程的功能。
     *
     * 关键点在于 核心线程数、最大线程数和任务队列数，执行流程如下，记住一点，优先级：核心线程数 > 任务队列数 > 最大线程数。
     *
     * 线程池中线程数小于核心线程数，直接创建新的核心线程。
     *
     * 如果线程数超过了超过核心线程数，任务会被插入到任务队列中等待执行。
     *
     * 如果任务队列也满了，这时会进入到最大线程(步骤4)的判断逻辑值。
     *
     * 如果线程池中线程数小于最大线程数，则启动一个非核心线程来执行。
     *
     * 如果果线程池中线程数超过了最大线程数，那没办法了，任务会被拒绝，ThreadPoolExecutor 会调用 RejectedExecutionHander 的 rejectedExecution 方法通知调用者。
     */
}
